package com.sign2024.sign2024project.goodsmaterials.service.impl;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.sign2024.sign2024core.common.utils.StringUtils;
import com.sign2024.sign2024core.entry.goodsmaterials.WzMajor;
import com.sign2024.sign2024core.entry.goodsmaterials.WzProgect;
import com.sign2024.sign2024core.entry.goodsmaterials.WzSpecialtySignRelation;
import com.sign2024.sign2024core.entry.projecttask.ProjectTask;
import com.sign2024.sign2024project.goodsmaterials.mapper.*;
import com.sign2024.sign2024project.goodsmaterials.param.WzParam;
import com.sign2024.sign2024project.goodsmaterials.service.WzProgectService;
import com.sign2024.sign2024project.goodsmaterials.vo.FamilyNextAndNumVo;
import com.sign2024.sign2024project.goodsmaterials.vo.WzProgectVo;
import com.sign2024.sign2024project.projecttask.mapper.ProjectTaskMapper;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @author yujie
 * @data 2024/8/26 15:20
 */
@Service
public class WzProgectServiceImpl implements WzProgectService {

    // 资格业绩条件
    @Resource
    private WzPerformanceMapper wzPerformanceMapper;

    //计划清单
    @Resource
    private WzPlanInventoryMapper wzPlanInventoryMapper;

    // 获取记录汇总
    @Resource
    private WzRecordCollectMapper wzRecordCollectMapper;

    // 任务
    @Resource
    private ProjectTaskMapper projectTaskMapper;

    // 物资历史
    @Resource
    private WzHistoryDataMapper wzHistoryDataMapper;

    // 物资 专业
    @Resource
    private WzMajorMapper wzMajorMapper;

    // 抽取方案
    @Resource
    private WzProgectMapper wzProgectMapper;

    // 物资 标段对应关系
    @Resource
    private WzSpecialtySignRelationMapper wzSpecialtySignRelationMapper;


//    @Override
//    public void processingWzDate(Integer taskId) {
////    public List<WzProgectVo> processingWzDate() {
////        Integer taskId = 36;
//        // 物资抽取方案基本信息
//        List<WzProgectVo> wzVos = wzPerformanceMapper.selectWzProgectVoData(taskId);
//        for (WzProgectVo wz : wzVos) {
//            // 根据 任务id 以及 签报名称 匹配 部门
//            List<String> depaList = wzPlanInventoryMapper.selectComDepa(taskId, wz.getSectionName());
//            String joinStrings = joinStrings(depaList);
//            wz.setComDepa(joinStrings);
//
//            // 根据 任务id 以及 ECP 计算 家数/家次
//            // 家数（去重）
//            int familyNumber = wzRecordCollectMapper.countFamilyNumber(taskId, wz.getSignName());
//            wz.setFamilyNumber(familyNumber);
//
//            // 家次 不去重
//            int familyNext = wzRecordCollectMapper.countFamilyNext(taskId, wz.getSignName());
//            wz.setFamilyNext(familyNext);
//
//
//            // 从专家专业与标段对应关系中 匹配 专家专业 五级匹配
//            WzSpecialtySignRelation relation = wzSpecialtySignRelationMapper.selectWzRelation(wz.getSectionName());
////            // 历史中匹配专业
////            String major = wzHistoryDataMapper.selectMajorByName(wz.getSectionName());
//            if (StringUtils.isNotNull(relation)) {
//                // 添加专家专业 1 - 5
//                // 使用 Optional 来简化四级匹配逻辑
//                Optional<String> signMajor = Stream.of(
//                                relation.getMajorOne(),
//                                relation.getMajorTwo(),
//                                relation.getMajorThree(),
//                                relation.getMajorFour(),
//                                relation.getMajorFive()
//                        )
//                        .filter(Objects::nonNull)
//                        .findFirst();
//
//                // 如果找到有效的专家专业，就设置到 jj 中
//                signMajor.ifPresent(wz::setSignMajor);
//            } else {
//                // 处理查询不到的情况
//                // 首先使用 四级评标专业进行匹配
//                List<WzMajor> wzMajors = wzMajorMapper.selectInfoByFour(wz.getSectionName());
//                if (wzMajors.size() == 1) {
//                    Optional<String> signMajor = Stream.of(
//                                    wzMajors.get(0).getMajorOne(),
//                                    wzMajors.get(0).getMajorTwo(),
//                                    wzMajors.get(0).getMajorThree(),
//                                    wzMajors.get(0).getMajorFour()
//                            )
//                            .filter(Objects::nonNull)
//                            .findFirst();
//                    // 如果找到有效的专家专业，就设置到 jj 中
//                    signMajor.ifPresent(wz::setSignMajor);
//                } else if (wzMajors.size() > 1) {
//                    // 大于1 说明数据有多条 进行合并
//                    for (WzMajor w : wzMajors) {
//                        List<String> strList = new ArrayList<>();
//                        if (StringUtils.isNotNull(w.getMajorOne())) {
//                            strList.add(w.getMajorOne());
//                        }
//                        wz.setSignMajor(joinStrings(strList));
//                    }
//                } else if (wzMajors.isEmpty()) {
//                    // 使用 3 去进行匹配
//                    List<WzMajor> wzMajors3 = wzMajorMapper.selectInfoByThree(wz.getSectionName());
//                    if (wzMajors3.size() == 1) {
//                        Optional<String> signMajor = Stream.of(
//                                        wzMajors3.get(0).getMajorOne(),
//                                        wzMajors3.get(0).getMajorTwo(),
//                                        wzMajors3.get(0).getMajorThree(),
//                                        wzMajors3.get(0).getMajorFour()
//                                )
//                                .filter(Objects::nonNull)
//                                .findFirst();
//                        // 如果找到有效的专家专业，就设置到 jj 中
//                        signMajor.ifPresent(wz::setSignMajor);
//                    } else if (wzMajors3.size() > 1) {
//                        for (WzMajor w : wzMajors3) {
//                            List<String> strList = new ArrayList<>();
//                            if (StringUtils.isNotNull(w.getMajorOne())) {
//                                strList.add(w.getMajorOne());
//                            }
//                            wz.setSignMajor(joinStrings(strList));
//                        }
//                    } else if (wzMajors3.isEmpty()) {
//                        // 使用 2 进行匹配
//                        List<WzMajor> wzMajors2 = wzMajorMapper.selectInfoByTwo(wz.getSectionName());
//                        if (wzMajors2.size() == 1) {
//                            Optional<String> signMajor = Stream.of(
//                                            wzMajors2.get(0).getMajorOne(),
//                                            wzMajors2.get(0).getMajorTwo(),
//                                            wzMajors2.get(0).getMajorThree(),
//                                            wzMajors2.get(0).getMajorFour()
//                                    )
//                                    .filter(Objects::nonNull)
//                                    .findFirst();
//                            // 如果找到有效的专家专业，就设置到 jj 中
//                            signMajor.ifPresent(wz::setSignMajor);
//                        } else if (wzMajors2.size() > 1) {
//                            for (WzMajor w : wzMajors2) {
//                                List<String> strList = new ArrayList<>();
//                                if (StringUtils.isNotNull(w.getMajorOne())) {
//                                    strList.add(w.getMajorOne());
//                                }
//                                wz.setSignMajor(joinStrings(strList));
//                            }
//                        } else {
//                            List<WzMajor> wzMajors1 = wzMajorMapper.selectInfoByTwo(wz.getSectionName());
//                            if (wzMajors1.size() == 1) {
//                                Optional<String> signMajor = Stream.of(
//                                                wzMajors1.get(0).getMajorOne(),
//                                                wzMajors1.get(0).getMajorTwo(),
//                                                wzMajors1.get(0).getMajorThree(),
//                                                wzMajors1.get(0).getMajorFour()
//                                        )
//                                        .filter(Objects::nonNull)
//                                        .findFirst();
//                                // 如果找到有效的专家专业，就设置到 jj 中
//                                signMajor.ifPresent(wz::setSignMajor);
//                            } else if (wzMajors1.size() > 1) {
//                                for (WzMajor w : wzMajors1) {
//                                    List<String> strList = new ArrayList<>();
//                                    if (StringUtils.isNotNull(w.getMajorOne())) {
//                                        strList.add(w.getMajorOne());
//                                    }
//                                    wz.setSignMajor(joinStrings(strList));
//                                }
//                            } else {
//                                System.out.println("查询不到");
//                            }
//                        }
//                    }
//                }
//            }
//
//
////            // 修改逻辑
////            // 处理查询不到的情况
////            // 首先使用 四级评标专业进行匹配
////            List<WzMajor> wzMajors = wzMajorMapper.selectInfoByFour(wz.getSectionName());
////            if (wzMajors.size() == 1) {
////                Optional<String> signMajor = Stream.of(
////                                wzMajors.get(0).getMajorOne(),
////                                wzMajors.get(0).getMajorTwo(),
////                                wzMajors.get(0).getMajorThree(),
////                                wzMajors.get(0).getMajorFour()
////                        )
////                        .filter(Objects::nonNull)
////                        .findFirst();
////                // 如果找到有效的专家专业，就设置到 jj 中
////                signMajor.ifPresent(wz::setSignMajor);
////            } else if (wzMajors.size() > 1) {
////                // 大于1 说明数据有多条 进行合并
////                for (WzMajor w : wzMajors) {
////                    List<String> strList = new ArrayList<>();
////                    if (StringUtils.isNotNull(w.getMajorOne())) {
////                        strList.add(w.getMajorOne());
////                    }
////                    wz.setSignMajor(joinStrings(strList));
////                }
////            } else if (wzMajors.isEmpty()) {
////                // 使用 3 去进行匹配
////                List<WzMajor> wzMajors3 = wzMajorMapper.selectInfoByThree(wz.getSectionName());
////                if (wzMajors3.size() == 1) {
////                    Optional<String> signMajor = Stream.of(
////                                    wzMajors3.get(0).getMajorOne(),
////                                    wzMajors3.get(0).getMajorTwo(),
////                                    wzMajors3.get(0).getMajorThree(),
////                                    wzMajors3.get(0).getMajorFour()
////                            )
////                            .filter(Objects::nonNull)
////                            .findFirst();
////                    // 如果找到有效的专家专业，就设置到 jj 中
////                    signMajor.ifPresent(wz::setSignMajor);
////                } else if (wzMajors3.size() > 1) {
////                    for (WzMajor w : wzMajors3) {
////                        List<String> strList = new ArrayList<>();
////                        if (StringUtils.isNotNull(w.getMajorOne())) {
////                            strList.add(w.getMajorOne());
////                        }
////                        wz.setSignMajor(joinStrings(strList));
////                    }
////                } else if (wzMajors3.isEmpty()) {
////                    // 使用 2 进行匹配
////                    List<WzMajor> wzMajors2 = wzMajorMapper.selectInfoByTwo(wz.getSectionName());
////                    if (wzMajors2.size() == 1) {
////                        Optional<String> signMajor = Stream.of(
////                                        wzMajors2.get(0).getMajorOne(),
////                                        wzMajors2.get(0).getMajorTwo(),
////                                        wzMajors2.get(0).getMajorThree(),
////                                        wzMajors2.get(0).getMajorFour()
////                                )
////                                .filter(Objects::nonNull)
////                                .findFirst();
////                        // 如果找到有效的专家专业，就设置到 jj 中
////                        signMajor.ifPresent(wz::setSignMajor);
////                    } else if (wzMajors2.size() > 1) {
////                        for (WzMajor w : wzMajors2) {
////                            List<String> strList = new ArrayList<>();
////                            if (StringUtils.isNotNull(w.getMajorOne())) {
////                                strList.add(w.getMajorOne());
////                            }
////                            wz.setSignMajor(joinStrings(strList));
////                        }
////                    } else {
////                        List<WzMajor> wzMajors1 = wzMajorMapper.selectInfoByTwo(wz.getSectionName());
////                        if (wzMajors1.size() == 1) {
////                            Optional<String> signMajor = Stream.of(
////                                            wzMajors1.get(0).getMajorOne(),
////                                            wzMajors1.get(0).getMajorTwo(),
////                                            wzMajors1.get(0).getMajorThree(),
////                                            wzMajors1.get(0).getMajorFour()
////                                    )
////                                    .filter(Objects::nonNull)
////                                    .findFirst();
////                            // 如果找到有效的专家专业，就设置到 jj 中
////                            signMajor.ifPresent(wz::setSignMajor);
////                        } else if (wzMajors1.size() > 1) {
////                            for (WzMajor w : wzMajors1) {
////                                List<String> strList = new ArrayList<>();
////                                if (StringUtils.isNotNull(w.getMajorOne())) {
////                                    strList.add(w.getMajorOne());
////                                }
////                                wz.setSignMajor(joinStrings(strList));
////                            }
////                        } else {
////                            String major = wzHistoryDataMapper.selectMajorByName(wz.getSectionName());
////                            if (StringUtils.isNotNull(major)) {
////                                wz.setSignMajor(major);
////                            }
////                        }
////                    }
////                }
////            }
//        }
//
//        List<WzProgectVo> wzProgectVos = new ArrayList<>();
//
//        List<WzProgectVo> tempVos = new ArrayList<>();
//
//        // 先对 wzVos 列表中的每个对象进行处理
//        for (WzProgectVo w : wzVos) {
//            // 查询其历史数据
//            List<String> historyList = wzHistoryDataMapper.selectHistoryName(w.getSectionName());
//            if (historyList.isEmpty()) {
//                tempVos.add(w);
//            } else {
//                // 遍历历史数据
//                for (String historyName : historyList) {
//                    // 对比历史数据与 wzVos 列表中的数据
//                    boolean existsInWzVos = wzVos.stream()
//                            .anyMatch(vo -> vo.getSectionName().equals(historyName));
//
//                    // 如果历史数据在 wzVos 中存在
//                    if (existsInWzVos) {
//                        // 检查 wzProgectVos 中是否已经存在相同的 sectionName
//                        boolean existsInWzProgectVos = wzProgectVos.stream()
//                                .anyMatch(vo -> vo.getSectionName().equals(historyName));
//                        // 如果 wzProgectVos 中不存在这条数据，则添加
//                        if (!existsInWzProgectVos) {
//                            // 找到 wzVos 中具有相同 sectionName 的对象
//                            WzProgectVo voToAdd = wzVos.stream()
//                                    .filter(vo -> vo.getSectionName().equals(historyName))
//                                    .findFirst()
//                                    .orElse(null);
//                            // 将找到的 WzProgectVo 对象添加到 wzProgectVos 中
//                            if (voToAdd != null) {
//                                wzProgectVos.add(voToAdd);
//                            }
//                        }
//                    }
//                }
//
//            }
////            wzProgectVos.add(w);
//        }
//
////        System.out.println(wzProgectVos.size());
//
//        if (!tempVos.isEmpty()) {
//            for (WzProgectVo w : tempVos) {
//                wzProgectVos.add(w);
//            }
//        }
//
//        // 获取 任务公式 信息
//        ProjectTask projectTask = projectTaskMapper.selectById(taskId);
//        // 技术评标量(家数/家次)
//        String skillFamily = projectTask.getSkillFamily();
//        // 商务 家数/家次
//        String businessFamily = projectTask.getBusinessFamily();
//
//        // 根据 家数/家次 获取技术总人数
//        int skillTotalPerson = 0;
//        // 判断是家数还是家次
//        if (skillFamily.equals("家数")) {
//            int totalFamilyNumber = wzProgectVos.stream()
//                    .mapToInt(WzProgectVo::getFamilyNumber)
//                    .sum();
//            // 向上取整 Math.ceil()
//            double v = Double.valueOf(totalFamilyNumber) / projectTask.getSkillSignNum();
//            skillTotalPerson = (int) Math.ceil(v);
//        } else {
//            // 计算 familyNext 的总和
//            int totalFamilyNext = wzProgectVos.stream()
//                    .mapToInt(WzProgectVo::getFamilyNext)
//                    .sum();
//            double v = Double.valueOf(totalFamilyNext) / projectTask.getSkillSignNum();
//            skillTotalPerson = (int) Math.ceil(v);
//        }
//
//        // 使用总人数 进行数据分组
//        List<Integer> classNumList =
//                DealClassUtils.dealGcClassNum(skillTotalPerson, projectTask.getSkillStart(), projectTask.getSkillEnd());
//        // 对技术进行分组
//        Map<String, List<WzProgectVo>> tempMap = new HashMap<>();
//        // 判断 有几个小组
//        if (classNumList.size() == 1) {
//            // 小组人数为 1 直接赋值
//            // 存储数据
//            List<WzProgectVo> oneList = new ArrayList<>();
//            for (int j = 0; j < wzProgectVos.size(); j++) {
//                wzProgectVos.get(j).setSkillTotalNum(classNumList.get(0));
//                oneList.add(wzProgectVos.get(j));
//            }
//
////            String className = "技术" + (tempMap.size() + 1) + "组";
//            String className = "技术" + convertToChinese(tempMap.size() + 1) + "组";
//            tempMap.put(className, oneList);
//        } else if (classNumList.size() == 2) {
//            // 为两组 分出一组 即可， 剩下即为一组
//            List<WzProgectVo> oneList = new ArrayList<>();
//            List<WzProgectVo> twoList = new ArrayList<>();
//
//            // 该小组 预计总评标量
//            Integer skillSignNum = projectTask.getSkillSignNum() * classNumList.get(0);
//            // 当前次 的总和
//            int total = 0;
//            // 下一次数据总和
//            int nextValue = 0;
//            //  遍历 集合计算 列表中的评标量
//            for (int j = 0; j < wzProgectVos.size(); ) {
//                // 判断是家数还是家次
//                if (skillFamily.equals("家数")) {
//                    total += wzProgectVos.get(j).getFamilyNumber();
//                } else {
//                    total += wzProgectVos.get(j).getFamilyNext();
//                }
//
//                if (total <= skillSignNum) {
//                    // 向map中添加数据值
//                    wzProgectVos.get(j).setSkillTotalNum(classNumList.get(0));
//                    oneList.add(wzProgectVos.get(j));
//                    wzProgectVos.remove(j);
//                } else {
//                    // 不满足 结束循环，避免其 无限循环
//                    break;
//                }
//                nextValue += 1;
//                if (nextValue > wzProgectVos.size()) {
//                    // 数据标记，避免无限循环
//                    break;
//                }
//            }
//            String className = "技术" + convertToChinese(tempMap.size() + 1) + "组";
//            tempMap.put(className, oneList);
//
//            for (int k = 0; k < wzProgectVos.size(); k++) {
//                wzProgectVos.get(k).setSkillTotalNum(classNumList.get(1));
//                twoList.add(wzProgectVos.get(k));
//            }
//            String className2 = "技术" + convertToChinese(tempMap.size() + 1) + "组";
//            tempMap.put(className2, twoList);
//        } else if (classNumList.size() > 2) {
//            // 这里 是3组 及以上
//            // 循环小组
//            for (int j = 0; j < classNumList.size(); j++) {
//                if (j == classNumList.size() - 1) {
//                    // 最后一次循环直接处理数据
//                    List<WzProgectVo> oneList = new ArrayList<>();
//                    if (!wzProgectVos.isEmpty()) {
//                        for (int k = 0; k < wzProgectVos.size(); k++) {
//                            wzProgectVos.get(k).setSkillTotalNum(classNumList.get(j));
//                            oneList.add(wzProgectVos.get(k));
//                        }
//                        String className = "技术" + convertToChinese(tempMap.size() + 1) + "组";
//                        tempMap.put(className, oneList);
//                    }
//                } else {
//                    List<WzProgectVo> oneList = new ArrayList<>();
//                    // 该小组 预计总评标量
//                    Integer skillSignNum = projectTask.getSkillSignNum() * classNumList.get(j);
//                    int total = 0;
//                    // 下一次数据总和
//                    int nextValue = 0;
//                    //  遍历 集合计算 列表中的评标量
//                    for (int k = 0; k < wzProgectVos.size(); ) {
//                        // 判断是家数还是家次
//                        if (skillFamily.equals("家数")) {
//                            total += wzProgectVos.get(k).getFamilyNumber();
//                        } else {
//                            total += wzProgectVos.get(k).getFamilyNext();
//                        }
//
//                        if (total <= skillSignNum) {
//                            // 向map中添加数据值
//                            wzProgectVos.get(k).setSkillTotalNum(classNumList.get(j));
//                            oneList.add(wzProgectVos.get(k));
//                            wzProgectVos.remove(k);
//                        } else {
//                            // 不满足 重新记录数据
//                            break;
//                        }
//
//                        nextValue += 1;
//                        if (nextValue > wzProgectVos.size()) {
//                            // 数据标记，避免无限循环
//                            break;
//                        }
//                    }
//                    // 获取组名
//                    String className = "技术" + convertToChinese(tempMap.size() + 1) + "组";
//                    tempMap.put(className, oneList);
//                }
//            }
//        }
//
//        List<WzProgectVo> vos = new ArrayList<>();
//        for (int i = 0; i < tempMap.size(); i++) {
////            String keyName = "技术" + (i + 1) + "组";
//            String keyName = "技术" + convertToChinese(i + 1) + "组";
//            List<WzProgectVo> voList = tempMap.get(keyName);
//            // 获取该小组 总人数
//            Integer skillTotalNum = voList.get(0).getSkillTotalNum();
//            // 分配异地人数
//            //  （技术专家总人数+1）÷3（向上取整）
//            double v = Double.valueOf((skillTotalNum + 1)) / projectTask.getOtherSkill();
//            int skillOtherNum = (int) Math.ceil(v);
//            // 最后必须确保 本地 人数 大于 projectTask.getOtherLocal() (本地保留人数)
//            // 求 集合总数
//            int totalFamily = 0;
//            if (skillFamily.equals("家数")) {
//                totalFamily = voList.stream()
//                        .mapToInt(WzProgectVo::getFamilyNumber)
//                        .sum();
//            } else {
//                // 计算 familyNext 的总和
//                totalFamily = voList.stream()
//                        .mapToInt(WzProgectVo::getFamilyNext)
//                        .sum();
//            }
//
//            int count = skillTotalNum;
//            for (WzProgectVo gc : voList) {
//                // 遍历集合 求占比
//                int temp = 0;
//                if (skillFamily.equals("家数")) {
//                    temp = gc.getFamilyNumber();
//                } else {
//                    // 计算 familyNext 的总和
//                    temp = gc.getFamilyNext();
//                }
//
//                // 计算占比
//                double proportion = (double) temp / totalFamily;
//                // 向上取整 Math.ceil()
//                int personNum = (int) Math.ceil(proportion * skillTotalNum);
//
//                if (count - personNum < 0) {
//                    personNum = count;  // 分配剩余的全部
//                }
//
//                // 更新count值
//                count -= personNum;
//
//                // 只在count大于0时进行赋值操作
//                if (count >= 0) {
//                    if (personNum > 0) {
//                        gc.setSkillMajorNum(personNum);
//                    }
//                }
//                // 分组
//                gc.setSkillClass(keyName);
//                vos.add(gc);
//            }
//        }
//
//        // 商务分组
//        // 根据 家数/家次 获取 商务
//        int bossTotalPerson = 0;
//        // 判断是家数还是家次
//        if (businessFamily.equals("家数")) {
//            int totalFamilyNumber = vos.stream()
//                    .mapToInt(WzProgectVo::getFamilyNumber)
//                    .sum();
//            // 向上取整 Math.ceil()
//            double v = Double.valueOf(totalFamilyNumber) / projectTask.getBusinessSignNum();
//            bossTotalPerson = (int) Math.ceil(v);
//        } else {
//            // 计算 familyNext 的总和
//            int totalFamilyNext = vos.stream()
//                    .mapToInt(WzProgectVo::getFamilyNext)
//                    .sum();
//            double v = Double.valueOf(totalFamilyNext) / projectTask.getBusinessSignNum();
//            bossTotalPerson = (int) Math.ceil(v);
//        }
//
//        // 使用总人数 进行数据分组
//        List<Integer> bossClassNumList =
//                DealClassUtils.dealGcClassNum(bossTotalPerson, projectTask.getBusinessStart(), projectTask.getBusinessEnd());
//        // 对技术进行分组
//        Map<String, List<WzProgectVo>> busTempMap = new HashMap<>();
//        // 判断 有几个小组
//        if (bossClassNumList.size() == 1) {
//            // 小组人数为 1 直接赋值
//            // 存储数据
//            List<WzProgectVo> oneList = new ArrayList<>();
//            for (int j = 0; j < vos.size(); j++) {
//                vos.get(j).setBossTotalNum(bossClassNumList.get(0));
//                oneList.add(vos.get(j));
//            }
////            String className = "商务" + (busTempMap.size() + 1) + "组";
//            String className = "商务" + convertToChinese(busTempMap.size() + 1) + "组";
//            busTempMap.put(className, oneList);
//        } else if (bossClassNumList.size() == 2) {
//            // 为两组 分出一组 即可， 剩下即为一组
//            List<WzProgectVo> oneList = new ArrayList<>();
//            List<WzProgectVo> twoList = new ArrayList<>();
//
//            // 该小组 预计总评标量
//            Integer skillSignNum = projectTask.getBusinessSignNum() * bossClassNumList.get(0);
//            // 当前次 的总和
//            int total = 0;
//            // 下一次数据总和
//            int nextValue = 0;
//            //  遍历 集合计算 列表中的评标量
//            for (int j = 0; j < vos.size(); ) {
//                // 判断是家数还是家次
//                if (businessFamily.equals("家数")) {
//                    total += vos.get(j).getFamilyNumber();
//                } else {
//                    total += vos.get(j).getFamilyNext();
//                }
//
//                if (total <= skillSignNum) {
//                    // 向map中添加数据值
//                    vos.get(j).setBossTotalNum(bossClassNumList.get(0));
//                    oneList.add(vos.get(j));
//                    vos.remove(j);
//                } else {
//                    // 不满足 结束循环，避免其 无限循环
//                    break;
//                }
//                nextValue += 1;
//                if (nextValue > vos.size()) {
//                    // 数据标记，避免无限循环
//                    break;
//                }
//            }
//            String className = "商务" + convertToChinese(busTempMap.size() + 1) + "组";
//            busTempMap.put(className, oneList);
//
//            for (int k = 0; k < vos.size(); k++) {
//                vos.get(k).setBossTotalNum(bossClassNumList.get(1));
//                twoList.add(vos.get(k));
//            }
//            String className2 = "商务" + convertToChinese(busTempMap.size() + 1) + "组";
//            busTempMap.put(className2, twoList);
//        } else if (bossClassNumList.size() > 2) {
//            // 这里 是3组 及以上
//            // 循环小组
//            for (int j = 0; j < bossClassNumList.size(); j++) {
//                if (j == bossClassNumList.size() - 1) {
//                    // 最后一次循环直接处理数据
//                    List<WzProgectVo> oneList = new ArrayList<>();
//                    if (!vos.isEmpty()) {
//                        for (int k = 0; k < vos.size(); k++) {
//                            vos.get(k).setBossTotalNum(bossClassNumList.get(j));
//                            oneList.add(vos.get(k));
//                        }
//                        String className = "商务" + convertToChinese(busTempMap.size() + 1) + "组";
//                        busTempMap.put(className, oneList);
//                    }
//                } else {
//                    List<WzProgectVo> oneList = new ArrayList<>();
//                    // 该小组 预计总评标量
//                    Integer skillSignNum = projectTask.getBusinessSignNum() * bossClassNumList.get(j);
//                    int total = 0;
//                    // 下一次数据总和
//                    int nextValue = 0;
//                    //  遍历 集合计算 列表中的评标量
//                    for (int k = 0; k < vos.size(); ) {
//                        // 判断是家数还是家次
//                        if (businessFamily.equals("家数")) {
//                            total += vos.get(k).getFamilyNumber();
//                        } else {
//                            total += vos.get(k).getFamilyNext();
//                        }
//
//                        if (total <= skillSignNum) {
//                            // 向map中添加数据值
//                            vos.get(k).setBossTotalNum(bossClassNumList.get(j));
//                            oneList.add(vos.get(k));
//                            vos.remove(k);
//                        } else {
//                            // 不满足 重新记录数据
//                            break;
//                        }
//
//                        nextValue += 1;
//                        if (nextValue > vos.size()) {
//                            // 数据标记，避免无限循环
//                            break;
//                        }
//                    }
//                    // 获取组名
//                    String className = "商务" + convertToChinese(busTempMap.size() + 1) + "组";
//                    busTempMap.put(className, oneList);
//                }
//            }
//        }
//
//        // 商务
//        List<WzProgectVo> finallyVos = new ArrayList<>();
//        for (int i = 0; i < busTempMap.size(); i++) {
////            String keyName = "商务" + (i + 1) + "组";
//            String keyName = "商务" + convertToChinese(i + 1) + "组";
//            List<WzProgectVo> voList = busTempMap.get(keyName);
//            // 获取该小组 总人数
//            Integer bossTotalNum = voList.get(0).getBossTotalNum();
//            // 分配异地人数
//            //  （技术专家总人数+1）÷3（向上取整）
//            double v = Double.valueOf((bossTotalNum + 1)) / projectTask.getOtherSkill();
//            int skillOtherNum = (int) Math.ceil(v);
//
//            // 2（本地）+13（异地）
//            // 使用总人数减去 异地 ，得到本地人数
//            int localNum = bossTotalNum - skillOtherNum;
//            if (localNum < projectTask.getOtherLocal()) {
//                // 如果不满足 任务 设定，倒退异地
//                localNum = projectTask.getOtherLocal();
//                skillOtherNum = bossTotalNum - localNum;
//            }
//
//            String personStr = localNum + "(本地) + " + skillOtherNum + "（异地）";
//
//            for (WzProgectVo gc : voList) {
//                // 人数
//                gc.setBossMajorNum(personStr);
//                // 分组
//                gc.setBossClass(keyName);
//                finallyVos.add(gc);
//            }
//        }
//
//        // 往数据库中 添加数据
//        wzProgectMapper.insertBatchVo(finallyVos, taskId);
//    }

    @Override
    public void processingWzDate(Integer taskId) {
        // 获取 任务公式 信息
        ProjectTask projectTask = projectTaskMapper.selectById(taskId);
        // 物资抽取方案基本信息
//        List<WzProgectVo> wzVos = wzPerformanceMapper.selectWzProgectVoData(taskId);
        List<WzProgectVo> wzVos = wzPerformanceMapper.selectWzProgectVoInfo(taskId);
        int serialNumber = 1;
        for (WzProgectVo wz : wzVos) {
            // 对 数值 顺序标记
            wz.setSerialNumber(serialNumber);
            serialNumber += 1;

            String signName = wzPerformanceMapper.selectSignNameByCode(wz.getSignCode());
            wz.setSignName(signName);


            // 根据 任务id 以及 签报名称 匹配 部门
            List<String> depaList = wzPlanInventoryMapper.selectComDepa(taskId, wz.getSectionName());
            String joinStrings = joinStrings(depaList, ",");
            wz.setComDepa(joinStrings);

//            // 匹配  大/中/小 三类描述
//            WzPlanInventory describe = wzPlanInventoryMapper.sekectDescribe(taskId, wz.getSectionName());
//            if (StringUtils.isNotNull(describe)) {
//                wz.setBigDescribe(describe.getBigDescribe());
//                wz.setMiddleDescribe(describe.getMiddleDescribe());
//                wz.setSmallDescribe(describe.getSmallDescribe());
//            }

            // 处理大类 中类 小类 数据 多条进行合并
            List<String> bigDescribe = wzPlanInventoryMapper.selectBigDescribe(taskId, wz.getSectionName());
            if (!bigDescribe.isEmpty()) {
                wz.setBigDescribe(joinStrings(bigDescribe, ","));
            }

            List<String> middleDescribe = wzPlanInventoryMapper.selectMiddleDescribe(taskId, wz.getSectionName());
            if (!middleDescribe.isEmpty()) {
                wz.setMiddleDescribe(joinStrings(middleDescribe, ","));
            }

            List<String> smallDescribe = wzPlanInventoryMapper.selectSmallDescribe(taskId, wz.getSectionName());
            if (!smallDescribe.isEmpty()) {
                wz.setSmallDescribe(joinStrings(smallDescribe, ","));
            }


            // 根据 任务id 以及 ECP 计算 家数/家次
            FamilyNextAndNumVo countFamily = wzRecordCollectMapper.countFamily(taskId, wz.getSignName());
            // 家数（去重）
            wz.setFamilyNumber(countFamily.getFamilyNumber());
            // 家次 不去重
            wz.setFamilyNext(countFamily.getFamilyNext());

            // 从专家专业与标段对应关系中匹配专家专业（五级匹配）
            WzSpecialtySignRelation relation = wzSpecialtySignRelationMapper.selectWzRelation(wz.getSectionName());
            if (StringUtils.isNotNull(relation)) {
                wz.setSignMajor(findFirstValidMajor(relation));
            } else {
                // 处理查询不到的情况
                List<WzMajor> wzMajors = findMajorsByLevel(wz.getSectionName());
                if (!wzMajors.isEmpty()) {
                    if (wzMajors.size() == 1) {
                        wz.setSignMajor(findFirstValidMajor(wzMajors.get(0)));
                    } else {
                        wz.setSignMajor(mergeMajors(wzMajors));
                    }
                } else {
                    // 如果所有级别都匹配不到任何专业
                    wz.setSignMajor(null);
                }
            }
        }

        Map<String, List<WzProgectVo>> tempMap = new HashMap<>();
        List<WzProgectVo> wzProgectVos = new ArrayList<>();
        // 存储 查询不到的数据
        List<WzProgectVo> tempVos = new ArrayList<>();
        // 先对 wzVos 列表中的每个对象进行处理
//        for (WzProgectVo w : wzVos) {
////            System.out.println(w.getSerialNumber());
//            // 频次
//            Integer frequency = projectTask.getFrequency();
//            if (frequency == null) {
//                frequency = 1;
//            }
//            // 查询其历史数据  以及 频次
//            List<String> historyList = wzHistoryDataMapper.selectHistoryName(w.getSectionName(), frequency);
//            if (historyList.isEmpty()) {
//                tempVos.add(w);
//            } else {
//                List<WzProgectVo> wz = new ArrayList<>();
//                for (String historyName : historyList) {
//                    boolean existsInWzVos = wzVos.stream()
//                            .anyMatch(vo -> vo.getSectionName().equals(historyName));
//                    if (existsInWzVos) {
//                        boolean existsInWzProgectVos = wzProgectVos.stream()
//                                .anyMatch(vo -> vo.getSectionName().equals(historyName));
//                        if (!existsInWzProgectVos) {
//                            WzProgectVo voToAdd = wzVos.stream()
//                                    .filter(vo -> vo.getSectionName().equals(historyName))
//                                    .findFirst()
//                                    .orElse(null);
//                            if (voToAdd != null) {
//                                wzProgectVos.add(voToAdd);
//                                wz.add(voToAdd);
//                            }
//                        }
//                    }
//                }
//
//                String className = "技术" + convertToChinese(tempMap.size() + 1) + "组";
//                if (!wz.isEmpty()) {
//                    tempMap.put(className, wz);
//                }
//            }
//        }

        for (WzProgectVo w : wzVos) {
            // 在 循环 之前， 先判断 是否以使用过
            boolean booleanVos = wzProgectVos.stream()
                    .anyMatch(vo -> vo.getSectionName().equals(w.getSectionName()));
            if (!booleanVos) {
                // 未 被 使用 对数据进行处理
                // 频次
                Integer frequency = projectTask.getFrequency();
                if (frequency == null) {
                    frequency = 1;
                }
                // 查询其历史数据  以及 频次
                List<String> historyList = wzHistoryDataMapper.selectHistoryName(w.getSectionName(), frequency);
                if (historyList.isEmpty()) {
                    tempVos.add(w);
                    wzProgectVos.add(w);
                } else {
                    List<WzProgectVo> wz = new ArrayList<>();
                    // 修改 一下， 通过 哪一个 查询 出来的，就先 匹配哪一个
                    // 先判断 已使用 的数据 是否 存在
                    boolean existsInWzProgectVos = wzProgectVos.stream()
                            .anyMatch(vo -> vo.getSectionName().equals(w.getSectionName()));
                    if (!existsInWzProgectVos) {
                        // 未 被使用过， 与 历史频次数据 进行对比
                        boolean existsInWzVos = wzVos.stream()
                                .anyMatch(vo -> vo.getSectionName().equals(w.getSectionName()));
                        if (existsInWzVos) {
                            // 如果历史 中 存在
                            // 判断是否 在 整体 集合中
                            WzProgectVo voToAdd = wzVos.stream()
                                    .filter(vo -> vo.getSectionName().equals(w.getSectionName()))
                                    .findFirst()
                                    .orElse(null);
                            if (voToAdd != null) {
                                wzProgectVos.add(voToAdd);
                                wz.add(voToAdd);
                            }
                        }
                    }


                    for (String historyName : historyList) {
                        // 先判断 已使用 的数据 是否 存在
                        boolean existsInWzProgectVos2 = wzProgectVos.stream()
                                .anyMatch(vo -> vo.getSectionName().equals(historyName));
                        if (!existsInWzProgectVos2) {
                            // 未 被使用过， 与 历史频次数据 进行对比
                            boolean existsInWzVos = wzVos.stream()
                                    .anyMatch(vo -> vo.getSectionName().equals(historyName));
                            if (existsInWzVos) {
                                // 如果历史 中 存在
                                // 判断是否 在 整体 集合中
                                WzProgectVo voToAdd = wzVos.stream()
                                        .filter(vo -> vo.getSectionName().equals(historyName))
                                        .findFirst()
                                        .orElse(null);
                                if (voToAdd != null) {
                                    wzProgectVos.add(voToAdd);
                                    wz.add(voToAdd);
                                }
                            }
                        }
                    }

                    String className = "技术" + convertToChinese(tempMap.size() + 1) + "组";
                    if (!wz.isEmpty()) {
                        tempMap.put(className, wz);
                    }
                }
            }
        }


        // 补充 历史中 查询不到的数据
        if (!tempVos.isEmpty()) {
//            // 按照 顺序标记 进行排序
            Collections.sort(tempVos,
                    Comparator.comparing(WzProgectVo::getSerialNumber));
            String className = "技术" + convertToChinese(tempMap.size() + 1) + "组";
            tempMap.put(className, tempVos);
        }

        // 技术评标量(家数/家次)
        String skillFamily = projectTask.getSkillFamily();
        // 商务 家数/家次
        String businessFamily = projectTask.getBusinessFamily();
        // 技术 组 最小人数
        Integer skillStart = projectTask.getSkillStart();

        for (int i = 0; i < tempMap.size(); i++) {
            String keyName = "技术" + convertToChinese(i + 1) + "组";
            List<WzProgectVo> voList = tempMap.get(keyName);
            if (voList.isEmpty()) {
                continue;
            }
            // 计算 商务 组 总人数
            int skillTotalPerson = 0;
            // 判断是家数还是家次
            if (skillFamily.equals("家数")) {
                int totalFamilyNumber = voList.stream()
                        .mapToInt(WzProgectVo::getFamilyNumber)
                        .sum();
                // 向上取整 Math.ceil() 商务人数
                double v = Double.valueOf(totalFamilyNumber) / projectTask.getSkillSignNum();
                // 四舍五入
                skillTotalPerson = (int) Math.round(v);
            } else {
                // 计算 familyNext 的总和
                int totalFamilyNext = voList.stream()
                        .mapToInt(WzProgectVo::getFamilyNext)
                        .sum();
                double v = Double.valueOf(totalFamilyNext) / projectTask.getSkillSignNum();
                skillTotalPerson = (int) Math.round(v);
            }
            // 判断四舍五入后是否为0，如果是则改为1
            if (skillTotalPerson <= 0) {
                skillTotalPerson = 1;
            }
            for (WzProgectVo vo : voList) {
                vo.setSkillTotalNum(skillTotalPerson);
            }
        }


        List<WzProgectVo> vos = new ArrayList<>();
        for (int i = 0; i < tempMap.size(); i++) {
            String keyName = "技术" + convertToChinese(i + 1) + "组";
            List<WzProgectVo> voList = tempMap.get(keyName);
            // 获取该小组 总人数
            // 计算 商务 组 总人数
            int skillTotalNum = 0;
            // 判断是家数还是家次
            if (skillFamily.equals("家数")) {
                int totalFamilyNumber = voList.stream()
                        .mapToInt(WzProgectVo::getFamilyNumber)
                        .sum();
                // 向上取整 Math.ceil() 商务人数
                double v = Double.valueOf(totalFamilyNumber) / projectTask.getSkillSignNum();
                // 四舍五入
                skillTotalNum = (int) Math.round(v);
            } else {
                // 计算 familyNext 的总和
                int totalFamilyNext = voList.stream()
                        .mapToInt(WzProgectVo::getFamilyNext)
                        .sum();
                double v = Double.valueOf(totalFamilyNext) / projectTask.getSkillSignNum();
                skillTotalNum = (int) Math.round(v);
            }
            // 判断四舍五入后是否为0，如果是则改为1
            if (skillTotalNum <= 0) {
                skillTotalNum = 1;
            }

            // 计算 异地 增加判断 条件 如果 总数 小于 最小值
            Integer skillOtherNum = null;
            Integer skillLocalNum = null;
            if (skillTotalNum < skillStart) {
                // 不计算异地 所有数据都是本地
                skillLocalNum = skillTotalNum;
            } else {
                // 计算 异地
                double v = Double.valueOf((skillTotalNum + 1)) / projectTask.getOtherSkill();
                skillOtherNum = (int) Math.ceil(v);
                skillLocalNum = skillTotalNum - skillOtherNum;
                if (skillLocalNum < projectTask.getOtherLocal()) {
                    // 如果不满足 任务 设定，倒退异地
                    skillLocalNum = projectTask.getOtherLocal();
                    skillOtherNum = skillTotalNum - skillLocalNum;
                }
            }

            // 求 集合总数
            int totalFamily = 0;
            if (skillFamily.equals("家数")) {
                totalFamily = voList.stream()
                        .mapToInt(WzProgectVo::getFamilyNumber)
                        .sum();
            } else {
                // 计算 familyNext 的总和
                totalFamily = voList.stream()
                        .mapToInt(WzProgectVo::getFamilyNext)
                        .sum();
            }

            // 按照 顺序标记 进行排序
//            Collections.sort(voList,
//                    Comparator.comparing(WzProgectVo::getSerialNumber));
            // 根据 gc.getSignMajor() 排序，处理 null 值
//            Collections.sort(voList, Comparator.comparing(WzProgectVo::getSignMajor, Comparator.nullsFirst(Comparator.naturalOrder())));
            // 使用 Map 存储每个 技术专家专业 对应的 FamilyNumber 总和
            Map<String, Integer> sumMap = new HashMap<>();

            for (WzProgectVo gc : voList) {
                // 本地
                gc.setSkillLocalNum(skillLocalNum);
                // 异地
                gc.setSkillOtherNum(skillOtherNum);
                // 总人数
                gc.setSkillTotalNum(skillTotalNum);
                // 获取 该 组 专业
                String signMajor = gc.getSignMajor();

                int temp = 0;
                if (skillFamily.equals("家数")) {
                    temp = gc.getFamilyNumber();
                } else {
                    temp = gc.getFamilyNext();
                }
                // 如果 SignMajor 已经在 Map 中，则累加 家数/家次
                if (signMajor != null) {
                    if (sumMap.containsKey(signMajor)) {
                        sumMap.put(signMajor, sumMap.get(signMajor) + temp);
                        // 相同专业 只 保留一个
//                        gc.setSignMajor(null);
                    } else {
                        // 否则，将 SignMajor 和 FamilyNumber 放入 Map
                        sumMap.put(signMajor, temp);
                    }
                }
            }

            int count = skillTotalNum;
            // 将 Map 转换为 List，并根据 Integer 值进行排序
            List<Map.Entry<String, Integer>> sortedList = new ArrayList<>(sumMap.entrySet());
            sortedList.sort((entry1, entry2) -> entry2.getValue().compareTo(entry1.getValue()));

            Map<String, Integer> personMap = new HashMap<>();
            for (Map.Entry<String, Integer> entry : sortedList) {
                // 计算占比
                double proportion = (double) entry.getValue() / totalFamily;
                // 向上取整 Math.ceil()
                int personNum = (int) Math.ceil(proportion * skillTotalNum);
                if (count - personNum < 0) {
                    // 分配剩余的全部
                    personNum = count;
                }
                count -= personNum;
                if (count >= 0) {
                    if (personNum > 0) {
                        personMap.put(entry.getKey(), personNum);
                    }
                }
            }

            Set<String> assignedMajors = new HashSet<>();
            for (Map.Entry<String, Integer> entry : personMap.entrySet()) {
                // 进行专业 对比
                for (WzProgectVo gc : voList) {
                    if (gc.getSignMajor() == null) {
                        continue;
                    }
                    // 这里 设置 一个字符串集合 将 已经赋值过了 专业 放到该 集合之中， 对数据进行赋值时 进行下专业 的对比， 不存在 进行下一步
                    // 如果该专业的技能编号已经赋值过，则跳过
                    if (assignedMajors.contains(gc.getSignMajor())) {
                        continue;
                    }

                    if (gc.getSignMajor().equals(entry.getKey())) {
                        gc.setSkillMajorNum(entry.getValue());
                        // 将该专业加入已赋值集合
                        assignedMajors.add(gc.getSignMajor());
                    }
                }
            }

            for (WzProgectVo gc : voList) {
                // 分组
                gc.setSkillClass(keyName);
                vos.add(gc);
            }
        }

        // 商务 分组 要 在 技术分组的技术上 进行
        // 根据 技术 组 的分组 将数据 封装到 map 中
        Map<String, List<WzProgectVo>> skillClassMap = vos.stream()
                .collect(Collectors.groupingBy(WzProgectVo::getSkillClass));
        // 计算 每组 所需 商务 总人数
        Integer start = projectTask.getBusinessStart();
        Integer end = projectTask.getBusinessEnd();
        int indexFlag = 1;
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < skillClassMap.size(); i++) {
            String keyName = "技术" + convertToChinese(indexFlag) + "组";
            indexFlag += 1;
            List<WzProgectVo> voList = tempMap.get(keyName);
            if (voList.isEmpty()) {
                continue;
            }
            // 计算 商务 组 总人数
            int busTotalPerson = 0;
            // 判断是家数还是家次
            if (businessFamily.equals("家数")) {
                int totalFamilyNumber = voList.stream()
                        .mapToInt(WzProgectVo::getFamilyNumber)
                        .sum();
                // 向上取整 Math.ceil() 商务人数
                double v = Double.valueOf(totalFamilyNumber) / projectTask.getBusinessSignNum();
                busTotalPerson = (int) Math.round(v);
            } else {
                // 计算 familyNext 的总和
                int totalFamilyNext = voList.stream()
                        .mapToInt(WzProgectVo::getFamilyNext)
                        .sum();
                double v = Double.valueOf(totalFamilyNext) / projectTask.getBusinessSignNum();
                busTotalPerson = (int) Math.round(v);
            }
            if (busTotalPerson == 0) {
                busTotalPerson = 1;
            }
            list.add(busTotalPerson);
        }

        // 下标集合
        List<Integer> flagList = countPersonFlag(end, list);
        // 累加集合
        List<Integer> sumTest = countSumFlag(end, list);
        // 自动向下取整
        Integer num = start / 2;
        for (int j = 0; j < sumTest.size(); j++) {
            Integer temp = sumTest.get(j);

            if (temp <= num) {
                if (j == 0) {
                    if (j + 1 >= sumTest.size()) {
                        sumTest.set(j, start);
                    } else {
                        flagList.set(j + 1, flagList.get(j) + 1);
                        flagList.remove(j);
                        sumTest.remove(j);
                        j--; // 因为删除了元素，需要减少j
                    }
                } else {
                    flagList.set(j - 1, flagList.get(j - 1) + 1);
                    flagList.remove(j);
                    sumTest.remove(j);
                    j--; // 因为删除了元素，需要减少j
                }
            } else if (temp < start) {
                sumTest.set(j, start);
            } else {
                boolean oddFlag = isOdd(temp);
                if (!oddFlag) {
                    if (temp > end) {
                        sumTest.set(j, temp);
                    } else {
                        sumTest.set(j, temp + 1);
                    }
                }
            }
        }

        Map<String, List<WzProgectVo>> busTempMap = new HashMap<>();

        int flag = 0;
        int prevIndex = 0;
        for (int j = 0; j < flagList.size(); j++) {
            int index = flagList.get(j);
            Integer totalNum = sumTest.get(j);
            List<WzProgectVo> arrayList = new ArrayList<>();
            for (int k = prevIndex + 1; k <= index; k++) {
                flag++;
                String keyName = "技术" + convertToChinese(flag) + "组";
                List<WzProgectVo> listWz = skillClassMap.getOrDefault(keyName, Collections.emptyList());
                // 填入 商务 分组 以及数据
                for (WzProgectVo vo : listWz) {
                    // 添加商务组 总人数
                    vo.setBossTotalNum(totalNum);
                }
                arrayList.addAll(listWz);
            }
            prevIndex = index;
            String name = "商务" + convertToChinese(busTempMap.size() + 1) + "组";
            busTempMap.put(name, arrayList);
        }

        // 商务
        List<WzProgectVo> finallyVos = new ArrayList<>();
        for (int i = 0; i < busTempMap.size(); i++) {
            String keyName = "商务" + convertToChinese(i + 1) + "组";
            List<WzProgectVo> voList = busTempMap.get(keyName);
            // 获取该小组 总人数
            Integer bossTotalNum = voList.get(0).getBossTotalNum();

            // 计算 异地 增加判断 条件 如果 总数 小于 最小值
            Integer skillOtherNum = null;
            Integer skillLocalNum = null;
            if (bossTotalNum < start) {
                // 不计算异地 所有数据都是本地
                skillLocalNum = bossTotalNum;
            } else {
                // 计算 异地
                double v = Double.valueOf((bossTotalNum + 1)) / projectTask.getOtherBusiness();
                skillOtherNum = (int) Math.ceil(v);
                skillLocalNum = bossTotalNum - skillOtherNum;
                if (skillLocalNum < projectTask.getOtherLocal()) {
                    // 如果不满足 任务 设定，倒退异地
                    skillLocalNum = projectTask.getOtherLocal();
                    skillOtherNum = bossTotalNum - skillLocalNum;
                }
            }

            if (voList.size() >= 2) {
                setMajors(voList, bossTotalNum);
            } else {
                while (voList.size() < 2) {
                    WzProgectVo vo = new WzProgectVo();
                    vo.setSkillClass(voList.get(0).getSkillClass());
                    voList.add(vo);
                }
                setMajors(voList, bossTotalNum);
            }

            for (WzProgectVo gc : voList) {
                //  人数
                gc.setBossMajorNum(String.valueOf(bossTotalNum));
                // 本地
                gc.setBossLoacalNum(skillLocalNum);
                // 异地
                gc.setBossOtherNum(skillOtherNum);
                // 分组
                gc.setBossClass(keyName);
                finallyVos.add(gc);
            }
        }
        // 往数据库中 添加数据
        wzProgectMapper.insertBatchVo(finallyVos, taskId);
    }

    @Override
    public int deleteByTaskId(Integer taskId) {
        return wzProgectMapper.deleteByTaskId(taskId);
    }

    @Override
    public int updateWzProgect(WzProgect wzProgect) {
        return wzProgectMapper.updateWzProgect(wzProgect);
    }

    @Override
    public Page<WzProgect> pageWzProgect(WzParam param) {
        Integer offset = (param.getPageNum() - 1) * param.getPageSize();
        param.setOffset(offset);

        // 分页查询
        Page<WzProgect> page = new Page<>(param.getPageNum(), param.getPageSize());
        List<WzProgect> list = wzProgectMapper.selectWzProgectByPage(param);

        // 页码
        page.setCurrent(param.getPageNum());
        page.setSize(param.getPageSize());

        // 总记录数
        Long aLong = wzProgectMapper.pageWzProgectCount(param);
        page.setTotal(aLong);
        page.setRecords(list);

        return page;
    }

    @Override
    public List<WzProgectVo> selectWzProgectVo(Integer taskId) {
        List<WzProgectVo> voList = wzProgectMapper.selectWzProgectVo(taskId);
//        int countIndex = 1;
//        for (WzProgectVo wz : voList) {
//            wz.setSerialNumber(countIndex);
//            countIndex += 1;
//        }
        return voList;
    }

    private void setMajors(List<WzProgectVo> voList, Integer totalNum) {
        for (int j = 0; j < voList.size(); j++) {
            if (j == 0) {
                voList.get(j).setBossSignMajor("财务审计");
//                voList.get(j).setBossMajorNum(1);
            } else if (j == 1) {
                voList.get(j).setBossSignMajor("商务综合");
//                voList.get(j).setBossMajorNum(1);
            }
        }
    }

    public static boolean isOdd(int number) {
        return number % 2 != 0;
    }

    public static List<Integer> countPersonFlag(Integer end, List<Integer> list) {
        Integer sum = 0;
        int indexFlag = 1;
        List<Integer> indices = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            sum += list.get(i);
            if (sum >= end || (i < list.size() - 1 && sum + list.get(i + 1) > end)) {
                // 记录当前索引 + 1
                indices.add(i + 1);
                // 将 sum 归零
                sum = 0;
            }
        }
        if (sum > 0) {
            // 如果循环结束时 sum 还有值，记录最后一个索引
            indices.add(list.size());

        }
        return indices;
    }


    public static List<Integer> countSumFlag(Integer end, List<Integer> list) {
        Integer sum = 0;
        List<Integer> values = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            sum += list.get(i);
            if (sum >= end || (i < list.size() - 1 && sum + list.get(i + 1) > end)) {
                // 记录当前的累加值
                values.add(sum);
                sum = 0;
            }
        }
        if (sum > 0) {
            // 记录最后一个累加值
            values.add(sum);
        }


        return values;
    }

    private List<WzMajor> findMajorsByLevel(String sectionName) {
        for (int level = 4; level >= 1; level--) {
            List<WzMajor> wzMajors = selectMajorsByLevel(sectionName, level);
            if (!wzMajors.isEmpty()) {
                return wzMajors;
            }
        }
        return new ArrayList<>();
    }

    private List<WzMajor> selectMajorsByLevel(String sectionName, int level) {
        switch (level) {
            case 4:
                return wzMajorMapper.selectInfoByFour(sectionName);
            case 3:
                return wzMajorMapper.selectInfoByThree(sectionName);
            case 2:
                return wzMajorMapper.selectInfoByTwo(sectionName);
            case 1:
                return wzMajorMapper.selectInfoByOne(sectionName);
            default:
                return new ArrayList<>();
        }
    }

    private String findFirstValidMajor(WzSpecialtySignRelation relation) {
        return Stream.of(
                        relation.getMajorOne(),
                        relation.getMajorTwo(),
                        relation.getMajorThree(),
                        relation.getMajorFour(),
                        relation.getMajorFive()
                )
                .filter(Objects::nonNull)
                .findFirst()
                .orElse(null);
    }

    private String findFirstValidMajor(WzMajor major) {
        return Stream.of(
                        major.getMajorOne(),
                        major.getMajorTwo(),
                        major.getMajorThree(),
                        major.getMajorFour()
                )
                .filter(Objects::nonNull)
                .findFirst()
                .orElse(null);
    }

    private String mergeMajors(List<WzMajor> wzMajors) {
        List<String> strList = wzMajors.stream()
                .filter(w -> w.getMajorOne() != null)
                .map(WzMajor::getMajorOne)
                .collect(Collectors.toList());
        return joinStrings(strList, "/ ");
    }

    /**
     * 根据 字符串 列表 拼接字符串
     *
     * @param stringList 字符串 列表
     * @return
     */
    public static String joinStrings(List<String> stringList, String flag) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < stringList.size(); i++) {
            sb.append(stringList.get(i));
            if (i < stringList.size() - 1) {
//                sb.append(",");
//                sb.append("/");
                sb.append(flag);
            }
        }
        return sb.toString();
    }

    // 传入 数字 返回 其中文样式
    public static String convertToChinese(int number) {
        if (number < 1 || number > 99) {
            throw new IllegalArgumentException("支持的范围是 1 到 99");
        }

        String[] chineseDigits = {"零", "一", "二", "三", "四", "五", "六", "七", "八", "九"};

        int tens = number / 10;
        int units = number % 10;

        StringBuilder result = new StringBuilder();

        if (tens > 0) {
            result.append(chineseDigits[tens]);
            result.append("十");
        }

        if (units > 0 || tens == 0) { // 处理个位是0的情况
            result.append(chineseDigits[units]);
        }

        // 如果只有十位数而个位数是0，不要显示个位的零
        return result.toString().replaceAll("^一十", "十"); // 将 "一十" 转换为 "十"
    }
}
